A Pascal programozási nyelv alapjai


Változók lehetséges típusai

Típus Érték
boolean (logikai, igaz vagy hamis) true, false
integer (egész szám) -32768 és 32767 közötti egész szám 
double (valós szám) 10.5
char (karakter) 'c'
string (szöveges) 'szoveg' (maximum 255 karakter)
stb...  


Változók, tömbök deklarálása
A változók deklarálása a változó nevének majd kettőspont után a típus megadásából áll. A deklarációkkal azonban vigyáznunk kell, ha egy metódusban tesszük azt meg, akkor az a változó csak az adott metóduson belül érhető el.
Példa deklarációra:
   var i:integer;   -    egyész típusú, i nevű változó deklarálása
   var f,t:boolean;   -    boolean típusú, f és t nevű változók deklarálása (vesszővel elválasztva megadhatjuk egy sorban is az azonos tíupsú elemeket a deklírációban)

Tömbök deklarálása
A tömbök olyan homogén adatszerkezetek, amelyek meghatározott számú elemet tartalmazhatnak. A homogén tulajdonság azt jelenti, hogy csak azonos típusú elemeket adhatunk meg tömbelemeknek.
Példa deklarációra:
   tomb:array [1..10] of integer;    -    így létrehoztunk egy 10 elemű, tomb nevű, egész típusú tömböt
A tömb elemeinek így adhatunk értéket:
   tomb[1]=20;   -   Java-val ellentétben itt a tömb elemeinek indexe eggyel kezdődik.


Változók értékének növelése és csökkentése
Változók értékének változtatását többféle képpen is megadhatjuk, ha eggyel kívánjuk növelni vagy csökkenteni, akkor azt így tehetjük meg:
     valtozo=valtozo+1;   vagy   valtozo=valtozo-1;
Ezzel egyenértékű a inc(valtozo); utasítás, csökkentéskor a dec(valtozo); utasítást használjuk.


Feltételes utasítások megadásakor használható műveleti jelek és jelentésük

 =      Egyenlőség vizsgálata.
 <     A bal oldalon lévő érték kisebb, mint a jobboldali
 >     A bal oldalon lévő érték nagyobb, mint a jobboldali
 <=    A bal oldalon lévő érték kisebb vagy egyenlő, mint a jobboldali, tehát már megengedett az egyenlőség is
 >=    A bal oldalon lévő érték nagyobb vagy egyenlő, mint a jobboldali, már megengedett az egyenlőség is


Feltételes utasítások logikai operátorokkal egészíthetőek ki, vagy kapcsolhatóak össze.
Logikai operátorok:

 and   Az ÉS operátor jele.
         Pl.: ((i>4) and (i<=20))  -  Ez a feltétel csak akkor teljesül, ha az i nagyobb, mint 4 ÉS kisebb vagy egyenlő 20-nál.
 or    A VAGY operátor jele.
         Pl.: ((x<10) or (x==1))  -  Ez a feltétel VAGY akkor teljesül, ha az x kisebb, mint 10, VAGY ha az x egyenlő eggyel.
 not   A NEM operátor jele.
       Pl.:  not(b<20)   -   Ez a feltétel akkor teljesül, ha a b NEM kisebb, mint 20.


Vezérlési szerkezetek
  • Ciklusok
    • for iklus
    • while ciklus
    • repeat - until ciklus
    • Kilépés a ciklusból (break)
  • Elágazások
    • Egyirányú elágazások
    • Kétirányú elágazások
    • Többirányú elágazások

Ciklusok

A for ciklus
Rögzített lépésszámú ciklus. Akkor hazsnáljuk, ha tudjuk, hogy a ciklus hányszor fog lefutni.
A for ciklus felépítése:

       for ciklusváltozó:=kezdőérték to változó_maximális_értéke do begin
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         end;  

A ciklus do utáni rész hajtódig végre mindaddig, amíg a változó el nem éri a megadott maximális értéket. A változó csak egész típusú lehet. A to jelenti az eggyel történő léptetést, növelését a változó értékének minden egyes lefutáskor eggyel. Ha csökkenteni szeretnénk akkor a to-t downto-ra kell cserélnünk, így:

      for ciklusváltozó:=kezdőérték downto változó_minimális_értéke do begin
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         end;  

Ha csak egy utasításból áll a ciklusmag a begin és end; elhagyható, ekkor az utasítást egyszerűen pontosvesszővel zárjuk.

A while ciklus
A while ciklus előltesztelő ciklus, tehát ha a ciklusfeltétel nem teljesül, a ciklusmag nem fut le. Így előforulhat az is, hogy a ciklus egyszer sem fut le.
A while ciklus felépítése:

      while (ciklusfeltétel) do begin
         ciklusmag
         end;  

A ciklus addig fut, amíg a ciklusfeltétel teljesül. (A lehetséges ciklusfeltételeket, azaz logikai kifejezéseket fentebb részleteztük.) Ha a ciklusmag csak egy utasításból áll, akkor a begin és az end; elhagyható.

A repeat - until ciklus
A repeat - until ciklus hátultesztelő ciklus, tehát attól függetlenül, hogy a ciklusfeltétel teljesül-e vagy sem, a ciklusmag mindenképpen lefut egyszer.
A repeat- until ciklus felépítése:

      repeat
         ciklusmag
         until(kilépési_feltétel);  

A ciklus addig fur, amíg a ciklusfeltétel már NEM teljesül, ez a kilépési feltétel lényege.

Kilépés a ciklusból (break)
A ciklusból történő kilépés a break; utasítással történik. Ennek köszönhetően a ciklusból "kiugrunk" és az utána következő utasítással folytatódik a program futása.


Elágazások

Egyirányú elágazások (if)
Az egyirányú elágazások felépítése:

      if(logikai_kifejezés) then begin
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         end;  

Az if feltételes utasításban szereplő utasítások csak akkor futnak le, ha a logikai kifejezés teljesül. A logikai kifejezés megadása után, ha csak egy utasítás áll, a begin és az end; elhagyható.

Kétirányú elágazások (if - else)
A kétirányú elágazások felépítése:

      if(logikai_kifejezés) then begin
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         end
      else begin
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         end; 

Ha a logikai kifejezések után csak egy utasítás szerepel, a begin és az end;  elhagyható. Az if-es kifejezést lezáró end után nem szabad pontosvesszőt tennünk, illetve ha end nincs, azaz csak egy utasítás van, azt sem zárhatjuk le pontosvesszővel, ha van utána else. A feltételes utasítások egymásba is ágyazhatóak.
Az egymásba ágyazott kétirányú elágazások felépítése:

      if(logikai_kifejezés) then begin
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         end
      else if(logikai_kifejezés) then begin
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         end
         else begin
            utasítás_1;
            utasítás_2;
            ...
            utasítás_n;
            end; 

A feltételes utasítások bármilyen mélységben egymásba ágyazthatóak.

Többirányú elágazások (case)
A többirányú elágazásokat akkor hazsnáljuk, amikor egy változó többféle értéket vehet fel, és a különböző esetekben más és más utasítás hajtódjon végre.
A többirányú elágazások felépítése:

      case(változó) of
         érték_1: utasítás_1; end;
         érték_2: utasítás_2; end;
         ...
         else: utasítás_n; end; 

Az of után adjuk meg a változó által felvehető lehetséges értéket majd kettősponttal elválasztva a végrehajtandó utasítást. Ezután egy end; utasítás következik, melynek köszönhetően átugunk a case-ben lévő további utasításokon. A többirányú elágazás esetén van egy olyan speciális lehetőségünk, amely minden egyéb nem megadott lehetőség esetén következik be, ezt a else: utasítás; paranccsal tehetjük meg.

Példát csak erre az elágazástípusra mutatunk be, mivel ez talán a legbonyolultabb, illetve a további programokban sem fog szerepelni ennek alkalmazása.
Erre példaként egy olyan programot írunk, amely billentyűzetről bekér egy érdemjegyet, és azt kiírja szövegesen.
A hozzá tartozó folyamatábra a következő:



program jegyek;
uses crt;
var jegy:integer;
BEGIN
   write ('Érdemjegy: ');
   readln(jegy);
   case(jegy) of
      1: writeln("Elégtelen"); end;
      2: writeln("Elégséges"); end;
      3: writeln("Közepes"); end;
      4: writeln("Jó"); end;
      5: writeln("Jeles"); end;
      else: writeln("???"); end;
END.


Metódusok
  • Eljárások
  • Függvények
Eljárások
Az eljárások felépítése:

      procedure eljárás_neve(formális_paraméterlista)
         begin
            eljárás_törzsrésze
            end;

A procedure jelzi, hogy eljárásról van szó, tehát nem lesz a metódusnak visszatérési értéke,.
Az eljárás neve után mindig szerepel a dupla kerek zárójel (), mely között a formális paraméterlista helyezkedik el. A formális paraméterlista a bemenő paraméterek nevét és típusát tartalmazza. Egy eljárásnak nem feltétlenül van bemenő paramétere, azok száma lehet 0, 1 vagy több is. Ha többet is megadunk, azokat pontosvesszővel választjuk el egymástól.

Függvények
A függvényt a visszatérési érték különbözteti meg az eljárástól.
A függvények felépítése:

     function függvény_neve(formális_paramlista):visszatérési_érték_típusa;
         begin
            függvény_törzsrésze
            függvény_neve:=viszatérési_érték;
            end; 

A visszatérési érték típusát a formális paraméterlista után kell megadnunk, ez lehet egésztípus, logikai, azaz boolean típus, String típus, satöbbi. A formális paraméterlista megadására ugyanaz vonatkozik, mint az eljárások esetében.
A visszatérési értéket a függvény_neve:=visszatérési_érték; utasítás adja vissza. Ezt a részt mindig tartalmaznia kell egy függvénynek, és nem szabad olyan feltételes utasításba helyeznünk, ami lehetséges, hogy nem teljesül, és így  az érték visszaadása nem kerül végrehajtásra.

A metódusok a Pascal nyelven írt programok törzsrészében kerülnek meghívásra. A bemenő paraméterek ekkor kapnak értéket. Mikor megadjuk egy metódus meghívásakor a paramétereket, azt aktuális paraméterlistának nevezzük.